using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml.Serialization;
using WorkOrderPrinter.Models;

namespace WorkOrderPrinter.Services
{
    public class TemplateService : ITemplateService
    {
        private readonly string _templatesFilePath;
        private List<PrintTemplate> _templates;

        public TemplateService()
        {
            // 获取应用程序数据目录
            string appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
            string appFolder = Path.Combine(appDataPath, "WorkOrderPrinter");
            
            // 确保目录存在
            if (!Directory.Exists(appFolder))
            {
                Directory.CreateDirectory(appFolder);
            }
            
            _templatesFilePath = Path.Combine(appFolder, "templates.xml");
            
            // 加载模板
            LoadTemplates();
        }

        private void LoadTemplates()
        {
            try
            {
                if (File.Exists(_templatesFilePath))
                {
                    using (var reader = new StreamReader(_templatesFilePath))
                    {
                        var serializer = new XmlSerializer(typeof(List<PrintTemplate>));
                        _templates = (List<PrintTemplate>)serializer.Deserialize(reader);
                    }
                }
                else
                {
                    // 如果没有模板文件，初始化一个空列表并添加默认模板
                    _templates = new List<PrintTemplate>();
                    AddDefaultTemplates();
                    SaveTemplates();
                }
            }
            catch (Exception)
            {
                // 处理加载错误，使用空列表
                _templates = new List<PrintTemplate>();
                AddDefaultTemplates();
            }
        }

        private void AddDefaultTemplates()
        {
            _templates.Add(new PrintTemplate
            {
                Id = Guid.NewGuid().ToString(),
                Name = "默认模板",
                Content = "型号: {Model}\r\n批次: {Batch}\r\n日期: {Date}\r\n起始序号: {InitialSerial}\r\n数量: {Quantity}\r\n备注: {Notes}",
                Model = "",
                BatchPattern = "",
                IsDefault = true
            });
        }

        private void SaveTemplates()
        {
            try
            {
                using (var writer = new StreamWriter(_templatesFilePath))
                {
                    var serializer = new XmlSerializer(typeof(List<PrintTemplate>));
                    serializer.Serialize(writer, _templates);
                }
            }
            catch (Exception ex)
            {
                // 处理保存错误
                throw new Exception("保存模板失败: " + ex.Message);
            }
        }

        public List<PrintTemplate> GetAllTemplates()
        {
            return new List<PrintTemplate>(_templates);
        }

        public PrintTemplate GetTemplateForWorkOrder(WorkOrder workOrder)
        {
            // 首先尝试找到完全匹配型号和批次模式的模板
            var match = _templates.FirstOrDefault(t => 
                !string.IsNullOrEmpty(t.Model) && 
                t.Model.Equals(workOrder.Model, StringComparison.OrdinalIgnoreCase) &&
                !string.IsNullOrEmpty(t.BatchPattern) &&
                workOrder.Batch.IndexOf(t.BatchPattern, StringComparison.OrdinalIgnoreCase) >= 0);

            // 如果没有找到，尝试仅匹配型号
            if (match == null)
            {
                match = _templates.FirstOrDefault(t => 
                    !string.IsNullOrEmpty(t.Model) && 
                    t.Model.Equals(workOrder.Model, StringComparison.OrdinalIgnoreCase));
            }

            // 如果没有找到，使用默认模板
            if (match == null)
            {
                match = _templates.FirstOrDefault(t => t.IsDefault);
            }

            // 如果没有默认模板，使用第一个模板
            if (match == null && _templates.Any())
            {
                match = _templates.First();
            }

            return match;
        }

        public bool SaveTemplate(PrintTemplate template)
        {
            try
            {
                var existing = _templates.FirstOrDefault(t => t.Id == template.Id);
                if (existing != null)
                {
                    _templates.Remove(existing);
                }
                else
                {
                    // 新模板分配ID
                    template.Id = Guid.NewGuid().ToString();
                }

                // 如果设置为默认模板，取消其他模板的默认设置
                if (template.IsDefault)
                {
                    foreach (var t in _templates.Where(t => t.IsDefault))
                    {
                        t.IsDefault = false;
                    }
                }

                _templates.Add(template);
                SaveTemplates();
                return true;
            }
            catch
            {
                return false;
            }
        }

        public bool DeleteTemplate(string templateId)
        {
            try
            {
                var template = _templates.FirstOrDefault(t => t.Id == templateId);
                if (template != null)
                {
                    // 不能删除最后一个模板
                    if (_templates.Count <= 1)
                        return false;

                    _templates.Remove(template);
                    
                    // 如果删除的是默认模板，设置第一个模板为默认
                    if (template.IsDefault && _templates.Any())
                    {
                        _templates[0].IsDefault = true;
                    }
                    
                    SaveTemplates();
                    return true;
                }
                return false;
            }
            catch
            {
                return false;
            }
        }
    }
}
